07. Numpy-矩阵处理

import numpy as np  # 导入NumPy库

# ==================== 方法1:使用二维数组创建矩阵(推荐) ====================
matrix1 = np.array([
    [1, 2, 3],  # 第一行
    [4, 5, 6],  # 第二行
    [7, 8, 9]   # 第三行
])
print('3×3矩阵:')
print(matrix1)

import numpy as np

# 单位矩阵：对角线为1，其余为0
identity = np.eye(3)
print('单位矩阵:')
print(identity)

# 零矩阵：2行3列全0
zeros = np.zeros((2, 3))
print('\n零矩阵:')
print(zeros)

# 全1矩阵：2行4列全1
ones = np.ones((2, 4))
print('\n全1矩阵:')
print(ones)

import numpy as np

# diag函数创建对角矩阵，参数为对角线元素
diag = np.diag([1, 2, 3])
print('对角矩阵:')
print(diag)

# ⚠️ 平台原始代码 - 请原样输入至教学平台（注释除外），平台才会判定答案正确
import numpy as np  # 导入NumPy数值计算库
#使用列表定义5月26日收益率数据 return_0526、权重数据 weight。
return_0526=[0.0172,0.0243,-0.0029,0.0021]
weight=[0.15,0.20,0.25,0.4]  # 定义列表weight
#计算投资组合日收益率
return_daily=np.dot(return_0526,weight).round(3)
print(f'投资组合5月26日收益率为:{return_daily}')  # 输出投资组合5月26日收益率为

import numpy as np

A = np.array([[1, 2, 3], [4, 5, 6]])   # 2×3矩阵
B = np.array([[7, 8], [9, 10], [11, 12]])  # 3×2矩阵

# 方法1: @运算符（推荐，Python 3.5+）
C1 = A @ B
print('方法1 - @运算符:')
print(C1)

# 方法2: np.matmul()函数
C2 = np.matmul(A, B)
print('\n方法2 - matmul函数:')
print(C2)

# 方法3: np.dot()函数
C3 = np.dot(A, B)
print('\n方法3 - dot函数:')
print(C3)

print(f'\n结果一致: {np.array_equal(C1, C2) and np.array_equal(C2, C3)}')

import numpy as np

# 3只股票在4个交易日的收益率矩阵（每行一只股票，每列一个交易日）
returns = np.array([
    [0.01, 0.02, -0.01, 0.03],   # 股票A
    [0.02, 0.01, 0.03, -0.01],   # 股票B
    [-0.01, 0.03, 0.02, 0.04]    # 股票C
])

# 投资组合权重：A 30%、B 50%、C 20%
weights = np.array([0.3, 0.5, 0.2])

# 矩阵乘法：权重(1×3) × 收益率(3×4) = 组合收益(1×4)
portfolio_returns = weights @ returns
print(f'投资组合每日收益率: {portfolio_returns}')

# 累计收益率
cumulative_return = np.prod(1 + portfolio_returns) - 1
print(f'期间累计收益率: {cumulative_return:.4%}')

import numpy as np

np.random.seed(42)
returns = np.random.randn(100, 3) * 0.02  # 100天×3只股票的随机收益率

# 协方差矩阵
cov_matrix = np.cov(returns, rowvar=False)
print('协方差矩阵:')
print(cov_matrix)

# 相关系数矩阵
corr_matrix = np.corrcoef(returns, rowvar=False)
print('\n相关系数矩阵:')
print(corr_matrix)

import numpy as np

np.random.seed(42)
returns = np.random.randn(100, 3) * 0.02
cov_matrix = np.cov(returns, rowvar=False)
corr_matrix = np.corrcoef(returns, rowvar=False)

# 标准差向量
std_devs = np.sqrt(np.diag(cov_matrix))
# 外积构造分母矩阵
corr_from_cov = cov_matrix / np.outer(std_devs, std_devs)
print('从协方差计算的相关系数矩阵:')
print(corr_from_cov)

print(f'\n两种方法一致: {np.allclose(corr_matrix, corr_from_cov)}')

import numpy as np

# 3只股票的协方差矩阵
cov_matrix = np.array([
    [0.0100, 0.0018, 0.0011],
    [0.0018, 0.0081, 0.0009],
    [0.0011, 0.0009, 0.0064]
])

weights = np.array([0.3, 0.5, 0.2])  # A 30%, B 50%, C 20%

# 矩阵运算：wΣw'
portfolio_var = weights @ cov_matrix @ weights.T
portfolio_std = np.sqrt(portfolio_var)

print(f'投资组合方差: {portfolio_var:.6f}')
print(f'投资组合标准差(波动率): {portfolio_std:.4%}')

import numpy as np

cov_matrix = np.array([
    [0.0100, 0.0018, 0.0011],
    [0.0018, 0.0081, 0.0009],
    [0.0011, 0.0009, 0.0064]
])
weights = np.array([0.3, 0.5, 0.2])

portfolio_std = np.sqrt(weights @ cov_matrix @ weights.T)
individual_stds = np.sqrt(np.diag(cov_matrix))
weighted_avg_std = np.sum(weights * individual_stds)

print(f'加权平均标准差: {weighted_avg_std:.4%}')
print(f'组合标准差:     {portfolio_std:.4%}')
print(f'风险降低:       {(weighted_avg_std - portfolio_std) / weighted_avg_std:.2%}')
# 体现了"不要把鸡蛋放在同一个篮子里"的原理

import numpy as np

# 因子载荷矩阵：3只资产对3个因子的敏感度
A = np.array([
    [1.2, 0.8, 0.5],  # 资产1
    [0.9, 1.1, 0.3],  # 资产2
    [0.7, 0.6, 0.9]   # 资产3
])

b = np.array([0.08, 0.06, 0.07])  # 资产超额收益率

# 求解因子收益：Ax = b
factor_returns = np.linalg.solve(A, b)
print('因子收益率:')
print(f'  因子1: {factor_returns[0]:.4%}')
print(f'  因子2: {factor_returns[1]:.4%}')
print(f'  因子3: {factor_returns[2]:.4%}')

# 验证
b_reconstructed = A @ factor_returns
print(f'\n验证通过: {np.allclose(b, b_reconstructed)}')

import numpy as np

A = np.array([[4, 7], [2, 6]])
print('矩阵A:')
print(A)

# 行列式
det_A = np.linalg.det(A)
print(f'\n行列式: {det_A:.4f}')

# 秩
rank_A = np.linalg.matrix_rank(A)
print(f'秩: {rank_A}')

# 逆矩阵
A_inv = np.linalg.inv(A)
print('\n逆矩阵 A^(-1):')
print(A_inv)

# 验证 A × A^(-1) = I
identity = A @ A_inv
print(f'\n是否为单位矩阵: {np.allclose(identity, np.eye(2))}')

import numpy as np

A = np.array([[4, 7], [2, 6]])
A_inv = np.linalg.inv(A)

# 方程组 Ax = b，解为 x = A^(-1) × b
b = np.array([1, 2])
x = A_inv @ b
print(f'方程组Ax=b的解: {x}')

import numpy as np

cov_matrix = np.array([
    [0.0100, 0.0018, 0.0011],
    [0.0018, 0.0081, 0.0009],
    [0.0011, 0.0009, 0.0064]
])

# eigh：对称矩阵的特征值分解（特征值升序排列）
eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)

print('特征值:')
for i, val in enumerate(eigenvalues):
    print(f'  λ{i+1} = {val:.6f}')

# 解释方差比例
explained_var_ratio = eigenvalues / eigenvalues.sum()
print(f'\n解释方差比例:')
for i, ratio in enumerate(explained_var_ratio):
    print(f'  PC{i+1}: {ratio:.2%}')

# 累计解释方差
cumulative_var = np.cumsum(explained_var_ratio)
print(f'\n累计解释方差:')
for i, cum_var in enumerate(cumulative_var):
    print(f'  前{i+1}个主成分: {cum_var:.2%}')

import numpy as np

# 超定系统：4个方程，2个未知数
A = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
b = np.array([1, 2, 3, 4])

# Moore-Penrose伪逆
A_pinv = np.linalg.pinv(A)

# 最小二乘解：最小化 ||Ax - b||²
x = A_pinv @ b
print(f'最小二乘解: {x}')

# 残差与均方误差
residual = b - (A @ x)
mse = np.mean(residual ** 2)
print(f'均方误差: {mse:.6f}')